package modele;

import position.PositionPassage;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
/**
 *
 * @author DONG Xiangxiang
 */
public class Champ{
    /*
    enregiste la forme de champ
    */
    private Polygon polygon;
    private int nbPoints;
    private Point centre;
    private Point index;
    private boolean disponible;
    private Mouton mouton;
    private Map<PositionPassage,Passage> passages;
    private static double COTE=40.0;
    
    public Champ(){
        this(new Point(250,250));
    }
   
    public Champ(Point p){
        polygon = new Polygon();
        centre = new Point();
        centre = p;
        disponible = true;
        index = new Point();
        nbPoints=6;
        passages = new HashMap<PositionPassage,Passage>();
        int ox = p.x;
        int oy = p.y;
        double angle = 2*Math.PI/nbPoints;
        double r=COTE;
        double startAngle = (Math.PI-angle)/2;
        for(int i=0; i<nbPoints; i++) {
            int x = (int)(ox+r*Math.cos(startAngle+i*angle));
            int y = (int)(oy+r*Math.sin(startAngle+i*angle));       
            polygon.addPoint(x,y);
        }
    }
    
    public void paint(Graphics g) {
        g.setColor(Color.GREEN);
        g.fillPolygon(polygon.xpoints, polygon.ypoints, nbPoints);   
        if(mouton!=null)
        {
            g.setColor(mouton.getBerger().getColorMouton());
            int r = (int)(COTE);
            int x = (int)(centre.x-r/2);
            int y = (int)(centre.y-r/2);
            g.fillOval(x, y, r, r);
        }
    }

    public Polygon getPolygon() {
        return polygon;
    }
    public boolean contains(Point p){
        return polygon.contains(p.x, p.y);
    }
    public Point getIndex() {
        return index;
    }

    public boolean isDisponible() {
        return disponible;
    }
    
    public int getNbPoints() {
        return nbPoints;
    }

    public static double getCOTE() {
        return COTE;
    } 

    public Point getCentre() {
        return centre;
    }
    public void setIndex(int niveau, int num) {
        this.index.setLocation(niveau,num);
    }
    public void setDisponible(boolean valeur) {
        this.disponible = valeur;
    }
   
    public Map<PositionPassage,Passage> getPassages() {
        return passages;
    }

    public void setPassages(PositionPassage pp,Passage passage) {
        this.passages.put(pp, passage);
    }

    /**
     * Si on place un mouton, on rend le champ indisponnible
     * @param mouton mouton placé sur le champs
     */
    public void setMouton(Mouton mouton) {
        if(mouton != null){
            this.mouton = mouton;
            this.disponible = false;
            mouton.setPosition(this);
        }
        else{
            this.disponible = true;
        }
    }
    public Mouton getMouton() {
        return mouton;
    }
    
    /**
     * Retourne le passage en commun
     * Si les deux champs n'ont pas de passage en commun on retourne null
     * @param champ le champ où l'on souhaite aller
     * @return le passage direct
     */
    public Passage retournePassageEnCommun(Champ champ){
        Passage passage = null;
        
        boolean trouve = false;
        
        // on récupère les passages du champ
        Set cles = this.passages.keySet();
        Iterator it = cles.iterator();
        
        while(!trouve && it.hasNext()){
            Object positionPassage = it.next();
            Object valeur = this.passages.get(positionPassage);
            
            // on cherche sur le second champ
            Set cles2 = this.passages.keySet();
            Iterator it2 = cles.iterator();
            
            while (!trouve && it2.hasNext()){
                Object positionPassage2 = it2.next();
                Object valeur2 = champ.getPassages().get(positionPassage);
                
                // on vérifie si les 2 passages sont identiques
                if(valeur == valeur2){
                    trouve = true;
                    passage = this.passages.get(null);
                }
            }
        }
        return passage;
    }
}
